package com.zelix;

import java.util.*;

public class aq extends zp
{

    private static String z[];

    public aq()
    {
    }

    public void b(String s)
    {
        int i = s.lastIndexOf('/');
        if(i != -1)
        {
            String s1 = s.substring(0, i);
            String as[] = d(s1);
            if(as.length > 0)
            {
                int j = 0;
                a(j, as);
            }
        }
    }

    void a(Hashtable hashtable)
    {
    }

    private Hashtable a(dd dd1, re re1, dq dq1, qy qy1, boolean flag, HashMap hashmap) {
        ArrayList arraylist;
        Hashtable hashtable;
        qy qy2;
        int i;
        boolean flag1;
        flag1 = tb.b;
        arraylist = c();
        hashtable = new Hashtable(px.a(arraylist.size()));
        qy2 = new qy(arraylist.size());
        for (i = 0; i < arraylist.size(); i++) {
            String s = (String) arraylist.get(i);
            if (dd1.d(s)) {
                hashtable.put(s, s);
                qy2.b(s, s);
            } else if (re1 != null && re1.q(s)) {
                String s1 = re1.h(s);
                if (s1 != null) {
                    hashtable.put(s, s1);
                    qy2.b(s1, s);
                } else {
                    hashtable.put(s, s);
                    qy2.b(s, s);
                }
            } else if (hashmap != null && hashmap.containsKey(s)) {
                cq cq1 = (cq) hashmap.get(s);
                if (!cq1.b()) {
                    String s2 = cq1.a();
                    hashtable.put(s, s2);
                    qy2.b(s2, s);
                }
            }
        }
        fy fy1;
        Enumeration enumeration;
        fy1 = new fy();
        enumeration = qy2.e();
        while (enumeration.hasMoreElements()) {
            Object obj;
            Object obj1;
            int j;
            obj = (String) enumeration.nextElement();
            obj1 = qy2.d(obj);
            for (j = 0; j < ((Vector) (obj1)).size(); j++) {
                Vector vector;
                int k;
                String s3 = (String) ((Vector) (obj1)).get(j);
                vector = qy1.d(s3);
                if (vector != null) {
                    for (k = 0; k < vector.size(); k++) {
                        mt mt1 = (mt) vector.get(k);
                        if (dd1.a(mt1))
                            fy1.b(obj, mt1.B(), mt1);
                    }
                }
            }
        }


        _L11:
        if (!flag) {
            Iterator iobj = super.a.iterator();
            while (iobj.hasNext()) {
                bq obj1 = (bq) ((Iterator) (iobj)).next();
                ((bq) (obj1)).a(dd1, re1, dq1, hashtable, qy2, fy1, qy1);
            }
            _L14:
            a(qy2.d());
        }
        if (flag1) {
            Enumeration enumeration1;
            HashSet obj = new HashSet();
            Hashtable obj1 = b();
            enumeration1 = ((Hashtable) (obj1)).keys();
            while (enumeration1.hasMoreElements()) {
                String s4;
                String s6;
                label0:
                {
                    s4 = (String) enumeration1.nextElement();
                    if (re1 != null && re1.q(s4)) {
                        String s5 = re1.h(s4);
                        if (s5 != null) {
                            hashtable.put(s4, s5);
                            ((HashSet) (obj)).add(s5);
                            if (!flag1)
                                continue; /* Loop/switch isn't completed */
                        }
                        hashtable.put(s4, s4);
                        ((HashSet) (obj)).add(s4);
                        if (!flag1)
                            continue; /* Loop/switch isn't completed */
                    }
                    if (dd1.d(s4)) {
                        hashtable.put(s4, s4);
                        ((HashSet) (obj)).add(s4);
                        if (!flag1)
                            continue; /* Loop/switch isn't completed */
                    }
                    cq cq2 = (cq) hashmap.get(s4);
                    if (cq2.b()) {
                        String s7 = cq2.a();
                        Object obj2 = (zp) ((Hashtable) (obj1)).get(s7);
                        if (obj2 == null)
                            obj2 = this;
                        s6 = dq1.a(s7, qy2, fy1, null, re1, dd1);
                        if (s7.length() <= 0)
                            break label0;
                        s6 = s7 + "/" + s6;
                        if (!flag1)
                            break label0;
                    }
                    s6 = cq2.a();
                }
                hashtable.put(s4, s6);
                ((HashSet) (obj)).add(s6);
            }
            _L17:
            a(((Set) (obj)));
        }
        return hashtable;
    }

    private void a(fy fy1, dd dd1, re re1) {
        if (re1 != null) {
            ArrayList arraylist;
            int i;
            int j;
            Hashtable hashtable = b();
            arraylist = re1.a();
            i = arraylist.size();
            for (j = 0; j < i; j++) {
                String s = (String) arraylist.get(j);
                String s1 = re1.h(s);
                if (s1 == null)
                    s1 = s;
                if (!dd1.d(s) && dd1.c(s1))
                    re1.d(z[12] + lt.a(s) + z[14] + lt.a(s1) + z[13] + lt.a(s1) + z[11]);
            }
            HashMap hashmap;
            Enumeration enumeration;
            hashmap = new HashMap();
            enumeration = fy1.d();
            while (enumeration.hasMoreElements()) {
                Object obj;
                Object obj1;
                String s2 = (String) enumeration.nextElement();
                if (!dd1.d(s2) && (!re1.q(s2) || re1.p(s2)))
                    continue; /* Loop/switch isn't completed */
                obj = fy1.b(s2);
                if (obj == null)
                    continue; /* Loop/switch isn't completed */
                obj1 = ((Hashtable) (obj)).keys();
                while (((Enumeration) obj1).hasMoreElements()) {
                    String s3 = (String) ((Enumeration) (obj1)).nextElement();
                    String s4 = (String) ((Hashtable) (obj)).get(s3);
                    String s5 = (String) hashmap.put(s4, s4);
                }
            }
//_L10:
            Enumeration enumeration1 = fy1.d();
            while (enumeration1.hasMoreElements()) {
                Hashtable hashtable1;
                Enumeration enumeration2;
                String obj = (String) enumeration1.nextElement();
                if (dd1.d(((String) (obj))) || !re1.q(((String) (obj))) || !re1.p(((String) (obj))))
                    continue; /* Loop/switch isn't completed */
                String obj1 = re1.h(((String) (obj)));
                hashtable1 = fy1.b(obj);
                if (hashtable1 == null)
                    continue; /* Loop/switch isn't completed */
                enumeration2 = hashtable1.keys();
                while (enumeration2.hasMoreElements()) {
                    String s6 = (String) enumeration2.nextElement();
                    String s7 = (String) hashtable1.get(s6);
                    String s8 = obj1 + s6;
                    String s9 = (String) hashmap.put(s8, s7);
                    if (s9 != null) {
                        hashmap.put(s8, s9);
                        re1.d(z[12] + lt.a(((String) (obj))) + z[14] + lt.a(((String) (obj1))) + z[16] + s9 + z[15] + s7 + "\"");
                    }
                }
            }
        }
    }

    HashMap a(dd dd1, re re1, String s) {
        HashMap hashmap;
        Iterator iterator;
        hashmap = new HashMap();
        iterator = super.a.iterator();
        while (iterator.hasNext()) {
            bq bq1 = (bq) iterator.next();
            String s1 = bq1.a();
            String s2;
            if (re1 != null && re1.q(s1)) {
                String s3 = re1.h(s1);
                if (s3 != null) {
                    s2 = s3;
                } else {
                    s2 = s1;
                }
            } else if (dd1.d(s1)) {
                s2 = s1;
            } else {
                hashmap.put(s1, s);
                s2 = s;
                bq1.a(hashmap, dd1, re1, s2);
            }
        }
        return hashmap;
    }

    public Hashtable b()
    {
        Hashtable hashtable = new Hashtable();
        b(hashtable);
        return hashtable;
    }

    public String a()
    {
        return "";
    }

    private fy a(Iterator iterator) {
        fy fy1;
        ArrayList arraylist;
        fy1 = new fy();
        arraylist = c();
        Collections.sort(arraylist, Collections.reverseOrder());
        while (iterator.hasNext()) {
            String s;
            int i;
            s = (String) iterator.next();
            s = s.replace(zo.d, '/');
            for (i = 0; i < arraylist.size(); i++) {
                String s1 = (String) arraylist.get(i);
                if (s.startsWith(s1) && s.length() > s1.length() && s.charAt(s1.length()) == '/') {
                    fy1.b(s1, s.substring(s1.length()), s);
                }
            }
        }
        return fy1;
    }

    public ArrayList c()
    {
        ArrayList arraylist = new ArrayList();
        b(arraylist);
        return arraylist;
    }

    private HashMap a(qy qy1, dd dd1, re re1, String s, fy fy1, nh nh1) {
        HashMap hashmap1;
        qy qy2;
        Iterator iterator;
        HashMap hashmap = a(dd1, re1, s);
        hashmap1 = new HashMap(px.a(hashmap.size()));
        qy2 = new qy();
        iterator = hashmap.entrySet().iterator();
        while (iterator.hasNext()) {
            java.util.Map.Entry entry = (java.util.Map.Entry) iterator.next();
            qy2.b(entry.getValue(), entry.getKey());
        }
        Enumeration enumeration = qy2.e();
        while (enumeration.hasMoreElements()) {
            String s1;
            wu wu1;
            HashMap hashmap2;
            HashMap hashmap3;
            Iterator iterator1;
            s1 = (String) enumeration.nextElement();
            HashSet hashset = null;
            if (re1 != null)
                hashset = re1.a(s1);
            if (hashset == null)
                hashset = new HashSet();
            hashset.add(s1);
            wu1 = new wu();
            hashmap2 = new HashMap();
            hashmap3 = new HashMap();
            iterator1 = hashset.iterator();
            while (iterator1.hasNext()) {
                String s2 = (String) iterator1.next();
                Vector vector1 = qy1.d(s2);
                if (vector1 != null && vector1.size() > 0) {
                    boolean flag = a(hashmap2, vector1, dd1, re1, wu1);
                    if (flag)
                        re1.d(z[3] + wu1.a());
                }
                Hashtable hashtable = fy1.b(s2);
                if (hashtable != null && hashtable.size() > 0) {
                    boolean flag1 = a(hashmap3, hashtable, wu1);
                    if (flag1)
                        re1.d(z[4] + wu1.a());
                }
            }
            Vector vector;
            int i;
            vector = qy2.d(s1);
            Collections.sort(vector);
            if (vector.size() > 0) {
                for (i = 0; i < vector.size(); i++) {
                    String s3;
                    cq cq1;
                    s3 = (String) vector.get(i);
                    Vector vector2 = qy1.d(s3);
                    if (vector2 != null) {
                        boolean flag2 = a(hashmap2, vector2, dd1, re1, wu1);
                        if (flag2) {
                            cq1 = new cq(this, s1, true);
                            hashmap1.put(s3, cq1);
                            nh1.e(z[2] + lt.a(s3) + z[0] + lt.a(s1) + z[1] + wu1.a() + "\"");
                        } else {
                            cq1 = new cq(this, s1);
                            hashmap1.put(s3, cq1);
                        }
                    } else {
                        cq1 = new cq(this, s1);
                        hashmap1.put(s3, cq1);
                    }
                    Hashtable hashtable1 = fy1.b(s3);
                    if (hashtable1 != null && hashtable1.size() > 0) {
                        boolean flag3 = a(hashmap3, hashtable1, wu1);
                        if (flag3) {
                            if (!cq1.b())
                                cq1.a(true);
                            nh1.e(z[2] + lt.a(s3) + z[0] + lt.a(s1) + z[1] + wu1.a() + "\"");
                        }
                    }
                }
            }
            hashmap1.put(vector.get(0), new cq(this, s1));
        }
        return hashmap1;
    }

    private String[] d(String s) {
        StringTokenizer stringtokenizer;
        int i;
        String as[];
        int j;
        stringtokenizer = new StringTokenizer(s, "/");
        i = stringtokenizer.countTokens();
        as = new String[i];
        for (j = 0; j < i; j++) {
            as[j] = stringtokenizer.nextToken();
        }
        return as;
    }

    public static String a(String s, wu wu1) {
        String s1;
        String s2;
        s1 = s.trim();
        s2 = null;
        if (s1.length() > 0) {
            s1 = s1.replace('.', '/');
            if (s1.startsWith("/")) {
                s2 = z[10];
            } else {
                if (s1.endsWith("/"))
                    s1 = s1.substring(0, s1.length() - 1);
                if (s1.indexOf("/") > -1) {
                    s2 = z[9];
                } else {
                    for (int i = 0; i < s1.length(); i++) {
                        if (!Character.isJavaIdentifierPart(s1.charAt(i))) {
                            s2 = z[8] + s1.charAt(i) + "'";
                            break;
                        }
                    }
                }
            }
        }
        wu1.a(s2);
        return s1;
    }

    private boolean a(HashMap hashmap, Vector vector, dd dd1, re re1, wu wu1) {
        boolean flag;
        ArrayList arraylist;
        int i;
        flag = false;
        arraylist = new ArrayList();
        for (i = 0; i < vector.size(); i++) {
            mt mt1 = (mt) vector.get(i);
            String s = mt1.j();
            if (re1 != null && re1.m(s)) {
                String s1 = re1.f(s);
                if (s1 == null)
                    s1 = s;
                String s3 = lt.h(s1);
                mt mt3 = (mt) hashmap.put(s3, mt1);
                if (mt3 == null || mt3 == mt1) {
                    arraylist.add(s3);
                } else {
                    hashmap.put(s3, mt3);
                    wu1.a(z[5] + mt3.l() + z[7] + mt1.l() + z[6]);
                    flag = true;
                }
            } else {
                if (!dd1.a(mt1))
                    continue; /* Loop/switch isn't completed */
                String s2 = mt1.B();
                mt mt2 = (mt) hashmap.put(mt1.B(), mt1);
                if (mt2 == null || mt2 == mt1) {
                    arraylist.add(s2);
                } else {
                    hashmap.put(s2, mt2);
                    wu1.a(z[5] + mt2.l() + z[7] + mt1.l() + z[6]);
                    flag = true;
                }
            }
        }
        for (int j = 0; j < arraylist.size(); j++) {
            Object obj = hashmap.remove(arraylist.get(j));
        }
        return flag;
    }

    private boolean a(HashMap hashmap, Hashtable hashtable, wu wu1) {
        boolean flag;
        ArrayList arraylist;
        Iterator iterator;
        flag = false;
        arraylist = new ArrayList();
        iterator = hashtable.entrySet().iterator();
        while (iterator.hasNext()) {
            String s;
            int i;
            java.util.Map.Entry entry = (java.util.Map.Entry) iterator.next();
            s = (String) entry.getKey();
            String s1 = (String) entry.getValue();
            String s2 = (String) hashmap.put(s, s1);
            if (s2 != null && !s2.equals(s1)) {
                flag = true;
                wu1.a(z[17] + s2 + z[7] + s1 + z[6]);
                hashmap.put(s, s2);
                for (i = 0; i < arraylist.size(); i++) {
                    hashmap.remove(arraylist.get(i));
                }
            }
            arraylist.add(s);
        }
        return flag;
    }

    public boolean d()
    {
        return super.a == null || super.a.size() == 0;
    }

    public Hashtable a(Enumeration enumeration, dd dd1, Iterator iterator, re re1, boolean flag, cy cy) {
        qy qy1;
        fy fy1 = a(iterator);
        a(fy1, dd1, re1);
        qy1 = new qy();
        while (enumeration.hasMoreElements()) {
            mt mt1 = (mt) enumeration.nextElement();
            qy1.b(mt1.m(), mt1);
        }
        eq eq1 = new eq(cy);
        return a(dd1, re1, ((dq) (eq1)), qy1, false, ((HashMap) (null)));
    }

    public void a(Set set) {
        int i;
        String as[];
        int j;
        Iterator iterator;
        super.a.clear();
        i = set.size();
        as = new String[i];
        j = 0;
        iterator = set.iterator();
        while (iterator.hasNext()) {
            as[j++] = (String) iterator.next() + "/";
        }
        int k;
        Arrays.sort(as, zw.a());
        for (k = 0; k < i; k++) {
            b(as[k]);
        }
    }

    public void a(mt amt[]) {
        int i;
        super.a.clear();
        for (i = 0; i < amt.length; i++) {
            b(amt[i].j());
        }
    }

    public Hashtable a(Enumeration enumeration, dd dd1, re re1, boolean flag, boolean flag1, String s, cy cy, 
            boolean flag2, String s1, Iterator iterator, nh nh1) {
        fy fy1;
        HashMap hashmap;
        qy qy1;
        fy1 = a(iterator);
        a(fy1, dd1, re1);
        hashmap = null;
        qy1 = new qy();
        while (enumeration.hasMoreElements()) {
            mt mt1 = (mt) enumeration.nextElement();
            qy1.b(mt1.m(), mt1);
        }
        if (flag2)
            hashmap = a(qy1, dd1, re1, s1, fy1, nh1);
        fq fq1 = new fq(cy, flag1, s);
        Hashtable hashtable = a(dd1, re1, ((dq) (fq1)), qy1, flag2, hashmap);
        return hashtable;
    }

    public void a(re re1)
    {
        Hashtable hashtable = b();
        a(re1, hashtable);
    }

    private void a(re re1, Hashtable hashtable) {
        if (re1 != null) {
            ArrayList arraylist;
            int i;
            arraylist = re1.a();
            for (i = 0; i < arraylist.size(); i++) {
                String s = (String) arraylist.get(i);
                if (!hashtable.containsKey(s))
                    re1.t(s);
            }
        }
    }

    private static String z(char[] chs) {
        for (int i = 0; i < chs.length; i++) {
            byte key = 0;
            switch (i % 5) {
                case 0: // '\0'
                    key = 0xd;
                    break;

                case 1: // '\001'
                    key = 81;
                    break;

                case 2: // '\002'
                    key = 78;
                    break;

                case 3: // '\003'
                    key = 101;
                    break;

                default:
                    key = 78;
                    break;
            }
            chs[i] ^= key;
        }
        return new String(chs).intern();
    }

    static
    {
        String as[];
        as = new String[18];
        as[0] = "*q'\013:bqi";
        as[1] = "*q,\000-l$=\000n7ql";
        as[2] = "N0 \013!yq-\n\"a0>\026+-!/\006%l6+Ei";
        as[3] = "]0-\016/j4n\b/}!'\013)-2!\013(a8-\021=-&'\021&-2\"\004=~q \004#hq+\035-a$=\f!c\"n_n";
        as[4] = "]0-\016/j4n\b/}!'\013)-2!\013(a8-\021n7q";
        as[5] = "X??\020/a8(\f+iq-\t/~\"n\013/`4=E(b#n\006\"l\"=\000=-v";
        as[6] = "*q9\n;a5n\006\"l\"&";
        as[7] = "*q/\013*-v";
        as[8] = "D?8\004\"d5n\006&l#/\006:h#nB";
        as[9] = "@><\000ny9/\013nb?+E?x0\"\f(d4<";
        as[10] = "A4/\001'c6n\025/n:/\002+-\"+\025/\1770:\n<-2&\004<l2:\000<";
        as[11] = "/q:\r/yq9\f\"aq \n:-3+E<h?/\b+i\177";
        as[12] = "]0-\016/j4nG";
        as[13] = "/q,\020:-%&\f=-&!\020\"iq<\000=x=:E'cq/E-a0=\rnz8:\rnn=/\026=-s";
        as[14] = "/q'\026n`0>\025+iq:\nn/";
        as[15] = "/q-\t/~9'\013)-&'\021&-s";
        as[16] = "/q,\020:-%&\f=-&!\020\"iq<\000=x=:E'cql";
        as[17] = "C> H-a0=\026nk8\"\000=-v";
        for(int i = 0;i<as.length;i++){
            as[i] = z(as[i].toCharArray());
        }
        z = as;
    }
}